import 'dart:convert';
import 'dart:typed_data';

class ByteUtil {
  ByteUtil._(); // 私有构造函数，防止实例化

  /// 将字节数组转换为字符串，默认带空格
  static String byteArrayToString(List<int> bytes, {bool withEmpty = true}) {
    return bytes.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join(withEmpty ? ' ' : '');
  }

  /// 带空格的16进制字符串，转字节数组，比如 "47 54 82 04 00 03 01 d8 ff"
  static List<int> hexStringToBytes(String hexString) {
    return hexString
        .split(' ')
        .map((hex) => int.parse(hex, radix: 16))
        .toList();
  }

  /// 16进制转带符号数字（2字节）
  static int toSignedInt2(int hex) {
    if (hex >= 0x8000) {
      hex = hex ^ 0xFFFF;
      hex = hex + 1;
      return -hex;
    } else {
      return hex;
    }
  }

  /// 16进制转带符号数字（1字节）
  static int toSignedInt1(int hex) {
    if (hex >= 0x80) {
      hex = hex ^ 0xFF;
      hex = hex + 1;
      return -hex;
    } else {
      return hex;
    }
  }

  /// 将字节转换为十进制字符串
  static String byteToDecimalString(int b) {
    return int.parse(byteToHexString(b), radix: 16).toString();
  }

  /// 将十进制字符串转换为字节
  static int decStringToByte(String decimalStr) {
    int value = int.parse(decimalStr);
    return value & 0xff;
  }

  /// 将字节转换为十六进制字符串
  static String byteToHexString(int b) {
    String hex = b.toRadixString(16).padLeft(2, '0');
    return hex;
  }

  /// 将字节数组转换为整数
  static int byteArrayToInt(List<int> bytes) {
    int res = 0;
    for (int i = 0; i < bytes.length; i++) {
      res += (bytes[i] & 0xff) << (i * 8);
    }
    return res;
  }

  /// 将整数转换为字节数组
  static List<int> intToBytes(int value) {
    return [
      value & 0xff,
      (value >> 8) & 0xff,
      (value >> 16) & 0xff,
      (value >> 24) & 0xff,
    ];
  }

  /// 将短整数转换为字节数组（2字节）
  static List<int> shortToByteArray(int s) {
    return [
      (s >> 8) & 0xff,
      s & 0xff,
    ];
  }

  /// 将字符串转换为字节数组，长度为strLen
  static List<int> stringToBytes(String str, int strLen) {
    if (strLen == 0) {
      return [];
    }
    List<int> bytes = utf8.encode(str);
    if (bytes.length < strLen) {
      return List<int>.from(bytes)..length = strLen;
    }
    return bytes.sublist(0, strLen);
  }

  /// 获取字节数组的子数组
  static List<int> getSubBytes(List<int> bytes, int start, int end) {
    if (start < 0 || end >= bytes.length || start > end) {
      return [];
    }
    return bytes.sublist(start, end + 1);
  }

  /// 获取非零字节数组
  static List<int> getBytesNonZero(List<int> bytes) {
    int count = bytes.length;
    for (int i = bytes.length - 1; i >= 0; i--) {
      if (bytes[i] != 0) {
        count = i + 1;
        break;
      }
    }
    return bytes.sublist(0, count);
  }

  /// 将字节数组转换为长整数
  static int bytesToLong(List<int> bytes) {
    ByteData byteData = ByteData.sublistView(Uint8List.fromList(bytes));
    return byteData.getInt64(0, Endian.little);
  }

  /// 将字节数组转换为短整数
  static int bytesToShort(List<int> bytes) {
    ByteData byteData = ByteData.sublistView(Uint8List.fromList(bytes));
    return byteData.getInt16(0, Endian.little);
  }

  /// 整数转二进制字符串，保证长度为 8 位，不足的左边补0，如 3 = 00000011
  static String intToBinaryString(int value) {
    return value.toRadixString(2).padLeft(8, '0');
  }
}
